ObjectExtension[Cast].cs

Go to the documentation of this file.

// <copyright file=mitlicense.md url=http://lsauer.mit-license.org/ >
//             Lo Sauer, 2013-2016
// </copyright>
// <summary>   A tested, generic, portable, runtime-extensible type converter library   </summary
// <language>  C# > 6.0                                                                 </language>
// <version>   3.1.0.2                                                                  </version>
// <author>    Lorenz Lo Sauer; people credited in the sources                          </author>
// <project>   https://github.com/lsauer/dotnet-portable-type-cast                      </project>
namespace Core.TypeCast
{
    using System;
    using System.Reflection;
    using System.Linq;
    using System.Runtime.CompilerServices;

    using Core.TypeCast.Base;
    using Core.Extensions;

    public static partial class ObjectExtension
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut CastTo<TOut>(this object self, TOut defaultValue = default(TOut))
        {
            TOut result;
            //self.TryCast(typeTo: typeTo, out result, defaultValue, throwException: false);

            self.TryCast<object, TOut>(out result, defaultValue, throwException: defaultValue?.IsDefaultValue() == true, unboxObjectType: true);
            return result;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut CastTo<TOut>(this object self)
        {
            TOut result;
            self.TryCast<object, TOut>(out result, default(TOut), throwException: false, unboxObjectType: true);
            return result;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static TOut CastTo<TIn, TOut>(this TIn? self, TOut defaultValue = default(TOut), bool withContext = false) where TIn : struct
        {
            TOut result;
            self.TryCast<object, TOut>(out result, defaultValue: default(TOut), throwException: false, unboxObjectType: false, contextInstance: (withContext ? new ConvertContext(default(TOut)) { Nullable = true} : null));
            return result;
        }

        public static TOut CastTo<TIn, TOut>(this TIn self, TOut defaultValue = default(TOut))
        {
            TOut result;

            // check for generic type
            if(ConverterCollection.Initialized == true
                && ConverterCollection.CurrentInstance?.Settings.AllowGenericTypes == false
                && typeof(TIn).IsConstructedGenericType == true)
            {
                throw new ConverterException(ConverterCause.ConverterArgumentGenericType);
            }

            self.TryCast<TIn, TOut>(out result, defaultValue, throwException: true);
            return result;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static object CastTo(this object self, Type typeTo, object defaultValue = null, bool unboxObjectType = true)
        {
            object result;
            self.TryCast(typeTo, out result, defaultValue, throwException: false, unboxObjectType: unboxObjectType);
            return result;
        }

        public static bool TryCast<TIn, TOut>(this TIn self, out TOut result, TOut defaultValue = default(TOut), bool throwException = false, bool unboxObjectType = false, IConvertContext contextInstance = null)
        {
            Converter converter;
            var typeArgument = (defaultValue == null || defaultValue.IsDefaultValue() == true) ? null : typeof(TOut);
            if(GetConverterOrDefault(self, out converter, out result, typeArgument: typeArgument, throwException: throwException, unboxObjectType: unboxObjectType))
            {
                return true;
            }

            return InvokeConvert(self, out result, defaultValue, throwException, converter, contextInstance: contextInstance);
        }

        public static bool TryCast(this object self, Type typeTo, out object result, object defaultValue, bool throwException = false, bool unboxObjectType = true, IConvertContext contextInstance = null)
        {
            Type typeFrom = null;
            Type typeArgument = null;
            if(unboxObjectType == true)
            {
                typeFrom = self.GetType();
                if(typeFrom == typeTo)
                {
                    result = (object)self;
                    return true;
                }

                typeArgument = defaultValue == null ? null : defaultValue.GetType();
            }

            Converter converter;
            if(GetConverterOrDefault(self, out converter, out result, typeArgument: typeArgument, typeTo: typeTo, throwException: throwException, unboxObjectType: true))
            {
                return true;
            }

            if(defaultValue == null)
            {
                defaultValue = typeTo.GetTypeInfo().GetDefault();
            }

            return InvokeConvert(self, out result, defaultValue, throwException, converter, contextInstance: contextInstance);
        }
    }
}